inspector: Use a dropdown for size groups

Use a GtkDropDown for the modes of size groups.

inspector: Use a dropdown for controllers

Use a GtkDropDown for the phases of event controllers.

inspector: Use a dropdown for attribute mapping

Use a GtkDropDown for the attribute mapping editor.

inspector: Use dropdowns in property editor

Replace combo boxes by dropdowns in the property editor.

filechooser: Use a dropdown for choices

filechooser: Use a dropdown for the filter combo

Replace an internal use of GtkComboBox with GtkDropDown.

Add GtkDropDown

This is a simple drop down control using list models.

xxx: isnanf() is some wtf

builderlistitemfactory: Precompile the xml

This is the one place where we can really take advantage
of precompiling, since we instantiate this template
over and over.

gtk-demo: Use single-click-activate for minesweeper

The explanation say we do, so do it.

Spread single-click-activate api

This makes sense to have in all the views,
not just GtkListView.

docs: Add a listview overview section

Add a conceptual overview for all the listmodel-based
widgets.

Fixes: #2214

gtk-demo: Add filtering to the settings demo

A demo of filtering with lists was missing so far.

gtk-demo: Demo columnview sorting

Enhance the settings demo to have a sortable column.

gtk-demo: Cosmetic improvements to the listview demos

Set default sizes, window titles and add more
detail to the descriptions.

gtk-builder-tool: Minimally validate <binding>

Check that the toplevel property name is legit.

testsuite: Add tests for GtkTreeListSorter

Add GtkTreeListRowSorter

This is a special-purpose sorter that can
apply the sorting of another sorter to the
levels of a GtkTreeListModel.

testcolumnview: Add sorters

column view title: Show sort indicators

columnview: Add a sort-by api

columnview: Add sorting

This is a somewhat large commit that:

- Adds GtkColumnViewSorter
This is a special-purpose, private sorter implementation which sorts
according to multiple sorters, allowing each individual sorter to be
inverted. This will be used with clickable column view headers.

- Adds a read-only GtkColumnView::sorter property
The GtkColumnView creates a GtkColumnViewSorter at startup that it uses
for this property.

- Adds a writable GtkColumnViewColumn::sorter property
This allows defining per-column sorters. Whenever an application sets a
sorter for a column, the header becomes clickable and whenever
a header is clicked, that column's sorter is prepended to the list of
sorters, unless it is already the first sorter, in which case we invert
its order. No column can be in the list more than once.

listview: Add single-click-activate

Add a single-click-activate property to GtkListView.

listitemwidget: Add single-click-activate

Add a mode to GtkListItemWidget that activates on
single click and selects on hover. Make
GtkListItemManager set this on its items
when its own 'property' of the same name is set.

builder-tool: Pass through CDATA where it makes sense

This avoids a ton of escaping for
GtkBuilderListItemFactory::bytes.

docs: Reorganize list widgets in their own chapter

fontchooserwidget: Port to listmodels

The port is kind of evil, in that it stores either a PangoFontFamily or a
PangoFontFace in the list, depending on if the fontchooser is configured
to select fonts or faces.
It also does not cache the font description anymore, so more calls to
pango_font_describe() may happen.

If both of these issues turn out problematic, the fontchooser would need
to resurrect GtkDelayedFontDescription again and put objects of that
type through the model.

These changes depend on Pango 1.46's introduction of listmodels and
various new getters, so the dependency has been upgraded.

Add some tests for expression binding

In particular, test that expressios can deal with object == this.

expression: Allow passing a this object to bind()

This gives a bit more control over the arguments passed to expressions.

gtk-demo: Add a Clocks demo

This demo is meant to showcase expressions.

It also needs the fixes in glib 2.64 to work properly.

xxx: Add a hack to make paintables transform to/from objects

See also: https://gitlab.gnome.org/GNOME/glib/merge_requests/1251

inspector: Remove private struct for prop editor

inspector: Make Controller page a GtkWidget

inspector: Remove private struct from controllers

columnview: Add header

This uses a custom GtkColumnViewTitle widget. So far that widget is
pretty boring, but that will change once we added
resizing, reordering, dnd, sorting, hiding/showing of columns or
whatever UIs we want.

tests: Add testcolumnview

columnview: Add a custom LayoutManager

The ColumnView now allocates column widths first and then the individual
rows use the new layout manager which looks at the column allocations to
allocate their children.

constraint-editor: Don't poke around in widget internals

columnview: Fix styling with Adwaita

- Use "treeview" as the node name
- Add .view style class

inspector: Port object tree to GtkColumnView

columnview: Add GtkColumnViewCell

It's a GtkListItemWidget subclass that tracks the column it belongs to
and allows the column to track it.

We also use this subclass to implement sizing support so columns share
the same size and get resized in sync.

widget: Add a hook for resizes

It's private, no APIs, we don't talk about it. But we will start using
it very soon, so we can do size request caching in columns and avoid
sizegroups...

columnview: Implement GtkScrollable

Just forward it to the listview for now.

columnview: Add listitems for the columns

They are not aligned in columns yet, but they do exist.

listitemwidget: Lazily create listitems

We only create them in root/unroot (they should be created in
appear/disappear, but that vfunc doesn't exist yet), that way we can
avoid expensive work while the widget isn't used for anything.

listitem: Move position/item/selected tracking to widget

This way, we can ensure it's always there when we need it (before the
item gets created) and gone when we don't (if some GC language holds on
to the item after we've destroyed the widget).

listitemwidget: Add a private struct

I had to rename the item property to list_item anyway, so I could just
do the next step with it.

listitemfactory: Simplify

Instead of 6 vfuncs, we now have 3 and rely on the factory keeping track
of what it needs to do.

We're doing lots of dancing from one object to another here, but this
will hopefully get simpler with further commits.

listitemfactory: Reorganize vfuncs

Instead of bind/rebind/update/unbind, we now just have update, and the
factories get to interpret that in the way they want.

listitem: Make this a GObject

This splits GtkListItem into 2 parts:

1. GtkListItem
   This is purely a GObject with public API for developers who want to
   populate lists. There is no chance to cause conflict with GtkWidget
   properties that the list implementation assumed control over and
   defines a clear boundary.
2. GtkListItemWidget
   The widget part of the listitem. This is not only fully in control of
   the list machinery, the machinery can also use different widget
   implementations for different list widgets like I inted to for
   GtkColumnView.

builder: Make gtk_builder_extend_with_template() work with objects

This will be relevant later when we introduce GtkListItem which is not a
GtkWidget.

gtk-demo: Add a Coverflow application launcher

This is roughly the simplest demo I could come up with.

But I documented it, so there's your tutorial.

Related: #2214

Add GtkSignalListItemFactory

So the poor Rust users can actually use this.

I would totally not use this ever!

columnview: Allow adding/removing columns

... and make that work in UI files via <child>, too.

gtk-demo: Add a minesweeper demo

The demo shows creating ones own listmodel and using it to fill a grid.

I am totally getting the hang of React btw:
500 lines of logic with no UI code and 100 lines of GtkBuilder XML and
I get a sweet UI.

Add GtkColumnView skeleton

It's just a copy/paste of the listview code with all the internals
gutted. The code doesn't do anything.

wip: Add GtkCoverFlow

The widget mostly works out of the box, but some tweaking may be
necessary (in particular in the theme) and the gtk-demo changes might
require removing before this is production-ready.

listbase: Take over anchor handling

With that, pretty much all code but allocating the widgets is gone from
the gridview and listview.

listbase: Add vfuncs to convert positions to/from coordinates

... and use that to implement PageUp/PageDown.

With that, all keyboard handling has been moved to GtkListBase.

listbase: Move focus moving keybindings here

The focus tracker is not yet moved because that depends on scroll_to()
support and we don't have that yet.
Whoops.
So we use a hack.

Remove gtk_selection_model_user_select_item() again

This reverts commit 6a164ab306dad9096bde736c907494c71086d3c4.

The function was awkward and we now have only one caller again, so we
can fold it back into it.

listbase: Move orientable implementation here

listbase: Move selection handling here

listbase: Move item manager here

Nothing really changes, because both ListView and GridView still keep
self->item_manager around, but it's set up to point at the base's item
manager.

This way we can slowly move things to GtkListBase that need the item
manager (like trackers).

listbase: Move GtkScrollable implementation

Shared code between GtkGridView and GtkListView.

Add GtkListBase

This is a base item for GTK's list widgets so they can share some (read:
hopefully a lot of) code.

gridview: Simplify allocation code

It doesn't fix the bug I'm after, but it looks a lot better.

listview: Port various gridview improvements

- Handle anchor as align + top/bottom
  This fixes behavior for cells that are higher than the view
- Add gtk_list_view_adjustment_is_flipped()
  This should fix RTL handling of horizontal lists
- Fix scrolling
  This should make scrolling more reliable, particularly on short lists
  that are only a few pages long.

demo: Add a file browser demo

gridview: Add move keybindings

gridview: Implement (un)select all

Adds listitem.select-all and listitem.unselect-all actions and installs
the same keybindings as the treeview for those actions.

gridview: Add a focus tracker

... and use that to properly update selections when moving around with
the arrow keys.

gridview: Implement list.scroll-to action

gridview: Add activation

gridview: Implement minimum row height

We only allocate a certain amount of widgets - and we don't want to run
out of them. So we make all widgets high enough for this to never
happen.

gridview: Implement the list.select-item action

selectionmodel: Add gtk_selection_model_user_select_item()

I'm not sure this should be public API because it's incredibly awkward.
But it should definitely be shared between list widget implementations.

gridview: Implement anchors and scrolling

listitemmanager: Handle NULL factory

Just don't call it and create empty listitems.

demo: Use a listview as sidebar

gtk-demo: Introduce awards

We need a way to get a useful listbox, so here we go!

builder: Autofill scope property of listitemfactory

I couldn't come up with a better way to automatically inherit the scope
in the builder list item factory that didn't involve a magic
incantation in the XML file. And I do not want developers to know magic
incantations to do a thing that should pretty much always be done.

builderlistitemfactory: Add scope argument

This way, the scope used when creating builder instances can be
influenced. This way, callbacks can be passed into the factory.

listitemfactory: Make the builder factory properly buildable

Turn the construct arguments into construct properties so that they can
be set from ui files.

listview: Add move keybindings

My god, these are a lot.

And my god, these are complicated to get right.

listview: Add gtk_list_view_get_position_at_y()

listitem: Add "listitem.select" action and keybindings for it

In fact, grab space with all modifiers to toggle selection of the
current item.

listview: Add a focus tracker

This ensures that the row with the input focus always stays available,
even when scrolled out of view.

listview: Implement (un)select all

Adds listitem.select-all and listitem.unselect-all actions and installs
the same keybindings as the treeview for those actions.

listview: Track focus movements and update selection

When focus moves via tab/arrow, we need to select the new item.

listview: Implement activation

- a GtkListview::activate signal
- a GtkListItem::activatable property
- activate list items on double clicks and <Enter> presses

treeexpander: Implement input support

This implements all the keybindings from GtkTreeView that can be
supported.

It does not implement expand-all, because supporting that means
causing the TreeListModel to emit lots of create_model vfuncs which in
turn would cause many items-changed signal which in turn would cause
many signal handlers to run which in turn would make "expand-all" very
reentrant, and I'm uneasy about supporting that.

For the mouse, just add a click gesture to the expander icon that toggles
expanded state.

listitem: Change focus handling

Focus in the listitem now works like this:
1. If any child can take focus, do not ever attempt
   to take focus.
2. Otherwise, if this item is selectable or activatable,
   allow focusing this widget.

This makes sure every item in a list is focusable for
activation and selection handling, but no useless widgets
get focused and moving focus is as fast as possible.

inspector: Make the recorder node list use a ListView

It's quite a bit faster now, but the code is also a bit more awkward.

Pain points:

- GtkTreeListModel cannot be created in UI files because it needs
  a CreateModelFunc.
  Using a signal for this doesn't work because autoexpand wants to
  expand the model before the signal handler is connected.

- The list item factory usage is still awkward. It's bearable here
  because the list items are very simple, but still.

inspector: Use a GtkTreeExpander in the object tree

inspector: Use a treeexpander in the recorder

demo: Add a GSettings tree demo

It is meant to look somewhat like dconf-editor when it is done.

So far, it's just a list.

Add GtkTreeExpander

This is a container widget that takes over all the duties of tree
expanding and collapsing.
It has to be a container so it can capture keybindings while focus is
inside the listitem.

So far, this widget does not allow interacting with it, but it shows the
expander arrow in its correct state.

Also, testlistview uses this widget now instead of implementing
expanding itself.

gridview: Actually do something

Implement measuring and allocating items - which makes the items appear
when drawing and allows interacting with the items.

However, the gridview still does not allow any user interaction
(including scrolling).

listview: Pass the CSS name of listitems to the manager

... instead of hardcoding "row".